Creating a world file and all about SDF in ROS 2

> #ros2-foxy     #gazebo-simulator

> In this blog, we will talk about world files in Gazebo, how to design a world through an image, why should you use an SDF file in ROS 2 as compared to an URDF file and ROS 2 launch files.

Author : Aryaman Shardul

Note : These instructions are for ROS 2 Foxy and Gazebo 11 and were tested on Ubuntu 20.4 LTS.

Table of Contents

• What is a world file in Gazebo
• How to design a world in Gazebo through an image
  • Interlinking of the various files
  • Designing the image
• SDF in ROS 2
  • What is a SDF file
  • Why use a SDF file in ROS 2
• What are launch files
  • ROS 2 launch files

What is a world file in Gazebo

• The world file contains a description of the world to be simulated by Gazebo.
• It describes the layout of robots, sensors, light sources, user interface components, and so on.
• The world file can also be used to control some aspects of the simulation engine, such as the force of gravity or simulation time step.
• Gazebo world files are written in XML.
• So, basically a world file helps to create an environment according to the purpose of the bot.
• It generally end with a .world extension.

How to design a world in Gazebo through an image

Interlinking of the various files

• Gazebo has an inbuilt 'Building Editor' which helps you to add walls, add objects, etc to your world.
• But in this blog, we will learn how to design a world through an image.
• As an example, we will be working on a world for a line follower robot.
• The first step is to have a very basic world file ready in the worlds folder in the src of our ROS 2 package.

    
    <model name="ground">
    <pose>1 2.3 -.1 0 0 0</pose>
    <static>1</static>
    <link name="ground">
      <collision name="ground_coll">
        <geometry>
          <box>
            <size>10 10 .1</size>
          </box>
        </geometry>
        <surface>
          <contact>
            <ode/>
          </contact>
        </surface>
      </collision>
      <visual name="ground_vis">
        <geometry>
          <box>
            <size>10 10 .1</size>
          </box>
        </geometry>
        <material>
          <script>
            <uri>models/course.material</uri>
            <name>course</name>
          </script>
        </material>
      </visual>
    </link>
    </model> 

• As you can observe from the above code snippet, the file has the very basic elements of a world in Gazebo.

• But the important thing to be noted is what is inside the script tag whose parent element is the material tag.

• This script tag contains an URI(Uniform Resource Identifier) which links our world file to the 'course.material' file located in the 'models' folder of the src.

• The contents of the models folder will describe the visual aspect of our world.

       
      material course
      {
        receive_shadows on
        technique
        {
          pass
          {
            ambient 0.5 0.5 0.5 1.0
            texture_unit
            {
              texture sra.png
            }
          }
        }
      }
  
  

• This file's main job is to connect the world file in our worlds folder with the image of our world located in our models folder.

• The name mentioned in the name tag of the script in the world file(here it's 'course') must match with the name on the first line after the word 'materials' in the course.material file.

• Lastly, we must have an image of the design of our world in the models folder.

• Note that this method is tried and test for images with '.png' and '.jpg' extensions.

Designing the image

• As mentioned earlier, we are designing a world for a line-follower robot as an example.
• For a line-follower robot, we need a decent path for it follow.
• Also, we need to give the path and it's surroundings different colours so that the bot can detect where is the line.
• To design the geometry of the path, we will use Autocad software as our path if full of curves. So to ensure uniform width of the path, we will use the 'offset' feature in autocad.
• Also, autocad has tools for drawing curves which will be very useful to us.
• After designing the path in autocad, export it as a png or jpg file.
• To add colours to the image, we can MS Paint or any other software similar to it.
• Finally, if we want a partcular size of the path, we again import the coloured image in autocad and use the 'scaling' feature in autocad to scale the image appropriately.
• Now you can launch this image as your world by using a ROS 2 launch file.
• In Gazebo, you can also you use the 'Building Editor' tool to add further details and objects to your world.
• Congratulations, you have successfully learnt to create your own world in Gazebo by designing an image.
• The images below are of two of the worlds in Gazebo designed by me for a line-follower bot.

• How they appear after being launched in Gazebo.

• Note : Always launch the world made by this method from inside of your ROS 2 package or else there may be a slight chance of the world not spawning properly.

SDF in ROS 2

What is a SDF file

• SDF is an acronym for Standard Database Format.
• A SDF file basically contains all the information about your model.
• The model may be your robot or your world with objects.
• It describes a robot’s physical description to ROS.
• It helps us define a robot so that we can test it in siumlation under various controlled conditions in a simulator like Gazebo.
• An URDF(Unified Robotic Description Format) file is similar to a SDF file.
• Both are written in XML.
• But both have some differences in terms of their syntax.
• Here is a small glimpse of my SDF file.

        
      <sdf version='1.7'>
          <model name='walle'>
            <link name='base_link'>
              <inertial>
                <pose>-0 0 -0.0025 0 -0 0</pose>
                <mass>0.00680000</mass>
                <inertia>
                  <ixx>0.000121426</ixx>
                  <ixy>1.28749e-19</ixy>
                  <ixz>2.00583e-22</ixz>
                  <iyy>0.000118984</iyy>
                  <iyz>-4.40398e-24</iyz>
                  <izz>0.000240029</izz>
                </inertia>
              </inertial>
              <collision name='base_link_collision'>
                <pose>0 0 0 0 -0 0</pose>
                <geometry>
                  <mesh>
                    <scale>1 1 1</scale>
                    <uri>meshes/base_link.STL</uri>
                  </mesh>
                </geometry>
              </collision>
              <collision name='base_link_fixed_joint_lump__camera_link_collision_1'>
                <pose>0.058 0 -0.015 0 -0 0</pose>
                <geometry>
                  <box>
                    <size>0.007 0.007 0.007</size>
                  </box>
                </geometry>
                <surface>
                  <contact>
                    <ode/>
                  </contact>
                  <friction>
                    <ode/>
                  </friction>
                </surface>
              </collision>     

Why use a SDF file in ROS 2

• In ROS2, the SpawnEntity method let's the SDF library handle the URDF conversion.
• But this may cause a problem if your bot contains meshes.
• It is possible that your meshes might not spawn when you spawn your bot.
• This is because an urdf model has package:// but the sdf::readString method transforms the package:// urls into model:// so they can be resolved by Gazebo.
• Hence, one of the ways to resolve this issue would be to convert your urdf file into a sdf file.
• This can be done by using the command, gz sdf -p file_name.urdf > file_name.sdf.
• Sometimes, even after converting into a SDF file, the meshes might not spawn.
• In such a case, try removing model://package_name from the uri and just keep the portion meshes/part_name.STL

What are launch files

• Launch files provide a convenient way to start up multiple nodes.
• They also let us define different parameters like the coordinates where we want to spawn the bot.
• They basically help us launch multiple things through a single file itself which saves us a lot of time and efforts.

ROS 2 launch files

• The launch files in ROS are mainly written in XML whereas those in ROS 2 are mainly written in python.
• I will explain about launch files with the help of code snippets from my launch file.
• My launch file launches Gazebo, my robot and my world all together.
• In the launch file, first we import all our dependencies and then create a function.
• Inside the function, we describe variables and assign them all the paths of the files we aim to launch.

        
          def generate_launch_description():
            model_path = GazeboRosPaths.get_paths()

            env = {
                "GAZEBO_MODEL_PATH": model_path,
            }

            sdf_prefix = get_package_share_directory("my_bot")
            sdf_file = os.path.join(sdf_prefix, "urdf", "walle.sdf")

            world_prefix = get_package_share_directory("my_bot")
            world_file = os.path.join(world_prefix, "worlds", "sra.world")
    
            rviz_config_prefix = get_package_share_directory("my_bot")
            rviz_config_path = os.path.join(rviz_config_prefix, 'rviz/urdf_config.rviz')

• Our launch file must return a launch description object. Through the return object, we launch all the things we want to.

      
      return LaunchDescription(
        [
            ExecuteProcess(
                cmd=[
                    "gazebo",
                    "-s",
                    "libgazebo_ros_init.so",
                    "-s",
                    "libgazebo_ros_factory.so",
                     world_file,
                ],
                output="screen",
                additional_env=env,
            ),
            Node(
                package="gazebo_ros",
                node_executable="spawn_entity.py",
                arguments=[
                    "-entity",
                    "walle",
                    "-x",
                    "-1",
                    "-y",
                    "0",
                    "-z",
                    ".41",
                    "-b",
                    "-file",
                    sdf_file,
                ],
            ),
            Node(
                package="robot_state_publisher",
                node_executable="robot_state_publisher",
                output="screen",
                arguments=[sdf_file],
            ),
            Node(
            package='rviz2',
            executable='rviz2',
            name='rviz2',
            output="screen",
            arguments=[rviz_config_path],
    )
        ]
    )

Conclusion

I hope you all have learnt something new from this blog and I encourage you all to try and create your own worlds in Gazebo using this method and launch your robots and worlds by creating your own launch files. Here is the link to my github repository so that you can go through the code and try it for yourselves.